#define _CRT_SECURE_NO_WARNINGS

#include"stack.h"

#include"Queue.h"

void testStack()
{
	Stack S;
	StackInit(&S);

	StackPush(&S, 1);
	StackPush(&S, 2);
	printf("%d ", StackTop(&S));
	StackPop(&S); printf("%d ", StackTop(&S));
	StackPop(&S);
	StackPush(&S, 3);
	StackPush(&S, 4);

	while (!StackEmpty(&S))
	{
		printf("%d ", StackTop(&S));
		StackPop(&S);
	}

	StackDestroy(&S);
}

void testQueue()
{
	Queue q;
	QueueInit(&q);

	QueuePush(&q, 1);
	QueuePush(&q, 2);
	printf("%d ", QueueFront(&q));
	QueuePop(&q); 
	printf("%d ", QueueFront(&q));
	QueuePop(&q);
	QueuePush(&q, 3);
	QueuePush(&q, 4);

	printf("  %d   ", QueueBack(&q));
	printf("  %d   ", QueueSize(&q));

	while (!QueueEmpty(&q))
	{
		printf("%d ", QueueFront(&q));
		QueuePop(&q);
	}


	QueueDestroy(&q);
}

//
//typedef struct {
//    Queue q1;
//    Queue q2;
//} MyStack;
//
//
//MyStack* myStackCreate() {
//    MyStack* obj = (MyStack*)malloc(sizeof(MyStack));
//    assert(obj);
//    QueueInit(&(obj->q1));
//    QueueInit(&(obj->q2));
//
//    return obj;
//}
//
//void myStackPush(MyStack* obj, int x) {
//    if (!QueueEmpty(&(obj->q1)))
//    {
//        QueuePush(&(obj->q1), x);
//    }
//    else
//    {
//        QueuePush(&(obj->q2), x);
//    }
//}
//
//int myStackPop(MyStack* obj) {
//    Queue* empty = &obj->q1, * notempty = &obj->q2;
//    if (!QueueEmpty(&(obj->q1)))
//    {
//        empty = &obj->q2;
//        notempty = &obj->q1;
//    }
//    int N = QueueSize(&notempty);
//    while (N-- > 1)
//    {
//        QueuePush(empty, QueueFront(notempty));
//        QueuePop(notempty);
//    }
//    int ret = QueueFront(notempty);
//    QueuePop(notempty);
//    return ret;
//}
//
//int myStackTop(MyStack* obj) {
//    if (!QueueEmpty(&(obj->q1)))
//    {
//        return QueueBack(&(obj->q1));
//    }
//    else
//    {
//        return QueueBack(&(obj->q2));
//    }
//}
//
//bool myStackEmpty(MyStack* obj) {
//    return QueueEmpty(&(obj->q1)) && QueueEmpty(&(obj->q2));
//}
//
//void myStackFree(MyStack* obj) {
//    QueueDestroy(&(obj->q1));
//    QueueDestroy(&(obj->q2));
//    free(obj);
//}
//
//
//
//void test1()
//{
//    MyStack* MS = myStackCreate();
//
//    myStackPush(MS, 1);
//    myStackPush(MS, 2);
//    myStackPush(MS, 3);
//    myStackPush(MS, 4);
//
//    //printf("%d\n", myStackTop(MS));
//
//    while (!myStackEmpty(MS))
//    {
//        printf("%d ", myStackPop(MS));
//    }
//
//
//    myStackFree(MS);
//}


//
//typedef struct {
//	Stack in;
//	Stack out;
//} MyQueue;
//
//
//MyQueue* myQueueCreate() {
//	MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
//	StackInit(&obj->in);
//	StackInit(&obj->out);
//	return obj;
//}
//
//void myQueuePush(MyQueue* obj, int x) {
//	StackPush(&obj->in, x);
//}
//
//int myQueuePop(MyQueue* obj) {
//	if (StackEmpty(&obj->out))
//	{
//		while (!StackEmpty(&obj->in))
//		{
//			StackPush(&obj->out, StackTop(&obj->in));
//			StackPop(&obj->in);
//		}
//	}
//	int ret = StackTop(&obj->out);
//	StackPop(&obj->out);
//	return ret;
//}
//
//int myQueuePeek(MyQueue* obj) {
//	if (StackEmpty(&obj->out))
//	{
//		while (!StackEmpty(&obj->in))
//		{
//			StackPush(&obj->out, StackTop(&obj->in));
//			StackPop(&obj->in);
//		}
//	}
//	return StackTop(&obj->out);
//}
//
//bool myQueueEmpty(MyQueue* obj) {
//	return StackEmpty(&obj->in) && StackEmpty(&obj->out);
//}
//
//void myQueueFree(MyQueue* obj) {
//	StackDestroy(&obj->in);
//	StackDestroy(&obj->out);
//	free(obj);
//}
//
//
//void test2()
//{
//	MyQueue* Q = myQueueCreate();
//
//	myQueuePush(Q, 1);
//	myQueuePush(Q, 2);
//	myQueuePush(Q, 3);
//	myQueuePush(Q, 4);
//
//	printf("%d\n", myQueuePeek(Q));
//
//
//	myQueueFree(Q);
//}
//



int main()
{
	//testStack();
	//testQueue();
    //test1();
	test2();

	return 0;
}